{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:28.689330Z",
     "start_time": "2025-01-20T11:27:24.265763Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)  #设备是cuda:0，即GPU，如果没有GPU则是cpu\n",
    "\n",
    "seed = 42\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 数据准备",
   "id": "1073bc64c567ba13"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:30.503939Z",
     "start_time": "2025-01-20T11:27:28.691334Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "from torch.utils.data import random_split\n",
    "\n",
    "# 训练集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# 测试集\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 这里用 random_split 按照 11 : 1 的比例来划分数据集\n",
    "train_ds, val_ds = random_split(train_ds, [55000, 5000], torch.Generator().manual_seed(seed))\n",
    "\n",
    "\n"
   ],
   "id": "55788f25672e1ebe",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "",
   "id": "4fffd32f199496a1"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:37.599615Z",
     "start_time": "2025-01-20T11:27:30.505941Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "_mean, _std = cal_mean_std(train_ds)\n",
    "transforms = nn.Sequential(\n",
    "    Normalize(mean=_mean, std=_std),\n",
    ")\n",
    "\n",
    "_mean, _std"
   ],
   "id": "f17a4198ee382763",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([0.2856]), tensor([0.3202]))"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:37.605224Z",
     "start_time": "2025-01-20T11:27:37.600616Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 从数据集到dataloader\n",
    "batch_size = 32\n",
    "# num_workers 多线程加载数据，提高效率\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True, num_workers=2)\n",
    "val_loader = torch.utils.data.DataLoader(val_ds, batch_size=batch_size, shuffle=False, num_workers=2)\n",
    "test_loader = torch.utils.data.DataLoader(test_ds, batch_size=batch_size, shuffle=False, num_workers=2)"
   ],
   "id": "ccdf8026c7024c31",
   "outputs": [],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 定义模型",
   "id": "b5e4f17ae389c008"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:37.613355Z",
     "start_time": "2025-01-20T11:27:37.608229Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class DepthWiseConv2d(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, bias=True):\n",
    "        # 等价于 super().__init__()\n",
    "        super(DepthWiseConv2d, self).__init__()\n",
    "        # depthwise卷积层，groups参数表示一个卷积核的每个通道分别进行运算 \n",
    "        self.depthwise_conv = nn.Conv2d(in_channels, in_channels, kernel_size, stride, padding, groups=in_channels,\n",
    "                                        bias=False)\n",
    "        # pointwise卷积层，1x1卷积\n",
    "        self.pointwise_conv = nn.Conv2d(in_channels, out_channels, 1, 1, 0, bias=bias)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = self.depthwise_conv(x)\n",
    "        x = self.pointwise_conv(x)\n",
    "        return x"
   ],
   "id": "24ff9d2414bf2431",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:37.630214Z",
     "start_time": "2025-01-20T11:27:37.615360Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self, activation=\"relu\"):\n",
    "        super(CNN, self).__init__()\n",
    "        self.activation = F.relu if activation == \"relu\" else F.selu\n",
    "        self.flattener = nn.Flatten()  # 展平层\n",
    "        # 卷积层\n",
    "        # padding=\"same\"：卷积后输出的大小与输入大小相同\n",
    "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=\"same\") \n",
    "        self.conv2 = DepthWiseConv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\")\n",
    "        self.conv3 = DepthWiseConv2d(in_channels=32, out_channels=64, kernel_size=3, padding=\"same\")\n",
    "        self.conv4 = DepthWiseConv2d(in_channels=64, out_channels=64, kernel_size=3, padding=\"same\")\n",
    "        self.conv5 = DepthWiseConv2d(in_channels=64, out_channels=128, kernel_size=3, padding=\"same\")\n",
    "        self.conv6 = DepthWiseConv2d(in_channels=128, out_channels=128, kernel_size=3, padding=\"same\")\n",
    "        # 池化层\n",
    "        # nn.MaxPool2d:这是 PyTorch 中的最大池化层，用于对输入数据进行降采样。\n",
    "        # kernel_size=2：池化核的大小，通常是一个正方形。\n",
    "        self.pool = nn.MaxPool2d(2, 2)  #池化核大小为2（2*2），步长为2\n",
    "        # 全连接层\n",
    "        # (32,128,3,3)->(32,128*3*3)\n",
    "        self.fc1 = nn.Linear(128 * 3 * 3, 128)\n",
    "        self.fc2 = nn.Linear(128, 10)  # 输出层，10个类别 #输出尺寸（32,10）\n",
    "\n",
    "        self.init_weights()  # 初始化权重\n",
    "\n",
    "    def init_weights(self):  # 初始化权重\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层、卷积层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                if m.bias is not None:\n",
    "                    nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        act = self.activation\n",
    "        x = self.pool(act(self.conv2(act(self.conv1(x)))))\n",
    "        x = self.pool(act(self.conv4(act(self.conv3(x)))))\n",
    "        x = self.pool(act(self.conv6(act(self.conv5(x)))))\n",
    "        x = self.flattener(x)  #展平\n",
    "        x = act(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "for idx, (key, value) in enumerate(CNN().named_parameters()):\n",
    "    print(f\"{key}\\tparamerters num: {np.prod(value.shape)}\")  # 打印模型的参数信息"
   ],
   "id": "d3016623476b4fd4",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv1.weight\tparamerters num: 288\n",
      "conv1.bias\tparamerters num: 32\n",
      "conv2.depthwise_conv.weight\tparamerters num: 288\n",
      "conv2.pointwise_conv.weight\tparamerters num: 1024\n",
      "conv2.pointwise_conv.bias\tparamerters num: 32\n",
      "conv3.depthwise_conv.weight\tparamerters num: 288\n",
      "conv3.pointwise_conv.weight\tparamerters num: 2048\n",
      "conv3.pointwise_conv.bias\tparamerters num: 64\n",
      "conv4.depthwise_conv.weight\tparamerters num: 576\n",
      "conv4.pointwise_conv.weight\tparamerters num: 4096\n",
      "conv4.pointwise_conv.bias\tparamerters num: 64\n",
      "conv5.depthwise_conv.weight\tparamerters num: 576\n",
      "conv5.pointwise_conv.weight\tparamerters num: 8192\n",
      "conv5.pointwise_conv.bias\tparamerters num: 128\n",
      "conv6.depthwise_conv.weight\tparamerters num: 1152\n",
      "conv6.pointwise_conv.weight\tparamerters num: 16384\n",
      "conv6.pointwise_conv.bias\tparamerters num: 128\n",
      "fc1.weight\tparamerters num: 147456\n",
      "fc1.bias\tparamerters num: 128\n",
      "fc2.weight\tparamerters num: 1280\n",
      "fc2.bias\tparamerters num: 10\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:37.641001Z",
     "start_time": "2025-01-20T11:27:37.631219Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 计算模型总参数量\n",
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "\n",
    "count_parameters(CNN())\n",
    "# 深度分离卷积网络可以有效减少参数量，提升模型的性能"
   ],
   "id": "767a384acd8eb5c9",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "184234"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 训练模型",
   "id": "8fb5dfcd77513c03"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:37.743620Z",
     "start_time": "2025-01-20T11:27:37.642007Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()  # 装饰器，禁止梯度计算\n",
    "def evaluate(model, data_loader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in data_loader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # 前向传播\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        # tensor.item() 获取tensor的数值，loss是只有一个元素的tensor\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # 预测\n",
    "        preds = logits.argmax(axis=-1)  # 预测类别\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())  # tensor转numpy，再转list\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)  # 计算准确率\n",
    "    return np.mean(loss_list), acc  # # 返回验证集平均损失和准确率\n"
   ],
   "id": "24550945260b9755",
   "outputs": [],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Save Best Model",
   "id": "6fd06a23a5bccc23"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:37.752424Z",
     "start_time": "2025-01-20T11:27:37.745626Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "        self.save_dir = save_dir  # 保存路径\n",
    "        self.save_step = save_step  # 保存步数\n",
    "        self.save_best_only = save_best_only  # 是否只保存最好的模型\n",
    "        self.best_metric = -1  # 最好的指标，指标不可能为负数，所以初始化为-1\n",
    "        # 创建保存路径\n",
    "        if not os.path.exists(self.save_dir):  # 如果不存在保存路径，则创建\n",
    "            os.makedirs(self.save_dir)\n",
    "\n",
    "    # 对象被调用时：当你将对象像函数一样调用时，Python 会自动调用 __call__ 方法。\n",
    "    # state_dict() 返回模型参数的字典，包括模型参数和优化器参数\n",
    "    # metric 是指标，可以是验证集的准确率，也可以是其他指标\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return  # 不是保存步数，则直接返回\n",
    "\n",
    "        if self.save_best_only:\n",
    "            assert metric is not None  # 必须传入metric\n",
    "            if metric >= self.best_metric:  # 如果当前指标大于最好的指标\n",
    "                # save checkpoint\n",
    "                # 保存最好的模型，覆盖之前的模型，不保存step，只保存state_dict，即模型参数，不保存优化器参数\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"03_cnn_best.ckpt\"))\n",
    "                self.best_metric = metric  # 更新最好的指标\n",
    "        else:\n",
    "            # 保存模型\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "            # 保存每个step的模型，不覆盖之前的模型，保存step，保存state_dict，即模型参数，不保存优化器参数\n"
   ],
   "id": "e93aec97aec45c4e",
   "outputs": [],
   "execution_count": 9
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Early Stopping",
   "id": "3f9a004729448217"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:37.759500Z",
     "start_time": "2025-01-20T11:27:37.754431Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        self.patience = patience  # 多少个step没有提升就停止训练\n",
    "        self.min_delta = min_delta  # 最小的提升幅度\n",
    "        self.best_metric = -1  # 记录的最好的指标\n",
    "        self.counter = 0  # 计数器，记录连续多少个step没有提升\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:  # 如果指标提升了\n",
    "            self.best_metric = metric  # 更新最好的指标\n",
    "            self.counter = 0  # 计数器清零\n",
    "        else:\n",
    "            self.counter += 1  # 计数器加一\n",
    "\n",
    "    @property  # 使用@property装饰器，使得 对象.early_stop可以调用，不需要()\n",
    "    def early_stop(self):\n",
    "        # 如果计数器大于等于patience，则返回True，停止训练\n",
    "        return self.counter >= self.patience\n"
   ],
   "id": "d8fdc303a4d27c00",
   "outputs": [],
   "execution_count": 10
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 训练",
   "id": "b56dab87e8ff6485"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:37.768709Z",
     "start_time": "2025-01-20T11:27:37.760503Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def training(model,\n",
    "             train_loader,\n",
    "             val_loader,\n",
    "             epoch,\n",
    "             loss_fct,\n",
    "             optimizer,\n",
    "             save_ckpt_callback=None,\n",
    "             early_stop_callback=None,\n",
    "             eval_step=500,\n",
    "             ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0  # 全局步数\n",
    "    model.train()  # 训练模式\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # 前向传播\n",
    "                logits = model(datas)\n",
    "                loss = loss_fct(logits, labels)  # 训练集损失\n",
    "                preds = logits.argmax(axis=-1)  # 预测类别\n",
    "\n",
    "                # 反向传播\n",
    "                optimizer.zero_grad()  # 梯度清零\n",
    "                loss.backward()  # 反向传播\n",
    "                optimizer.step()  # 优化器更新参数\n",
    "\n",
    "                # 计算准确率\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss,\n",
    "                    \"acc\": acc,\n",
    "                    \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # 评估\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()  # 评估模式\n",
    "                    # 验证集损失和准确率\n",
    "                    val_loss, val_acc = evaluate(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss,\n",
    "                        \"acc\": val_acc,\n",
    "                        \"step\": global_step\n",
    "                    })\n",
    "                    model.train()  # 训练模式\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        # model.state_dict() 返回模型参数的字典，包括模型参数和优化器参数\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), val_acc)\n",
    "                        # 保存最好的模型，覆盖之前的模型，保存step，保存state_dict,通过metric判断是否保存最好的模型\n",
    "\n",
    "                    # 3. 早停 early stopping\n",
    "                    if early_stop_callback is not None:\n",
    "                        # 验证集准确率不再提升，则停止训练\n",
    "                        early_stop_callback(val_acc)\n",
    "                        # 验证集准确率不再提升，则停止训练\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict  # 早停，返回记录字典 record_dict\n",
    "\n",
    "                # 更新进度条和全局步数\n",
    "                pbar.update(1)  # 更新进度条\n",
    "                global_step += 1  # 全局步数加一\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict  # 训练结束，返回记录字典 record_dict\n"
   ],
   "id": "2602ccd3cb633f69",
   "outputs": [],
   "execution_count": 11
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "",
   "id": "d111e077fd6e015"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T11:27:37.780067Z",
     "start_time": "2025-01-20T11:27:37.770715Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 100\n",
    "\n",
    "activation = \"selu\"  # 激活函数\n",
    "model = CNN(activation)  # 定义模型\n",
    "\n",
    "# 1. 定义损失函数 采用MSE损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "\n",
    "# 2. 定义优化器 采用SGD优化器\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 3.save model checkpoint\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(save_dir=\"checkpoints\", save_step=500, save_best_only=True)\n",
    "\n",
    "# 4. early stopping\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.01)"
   ],
   "id": "8b42caff09582576",
   "outputs": [],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T12:04:29.140895Z",
     "start_time": "2025-01-20T11:27:37.782075Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = model.to(device)  # 将模型移到GPU上\n",
    "\n",
    "# 训练过程\n",
    "record_dict = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=1000\n",
    ")"
   ],
   "id": "1b4d7f1cfe612c71",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/171900 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "9ba65a4dcf4d4de8b68c982fa55572f2"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 31 / global_step 54000\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T12:04:29.416439Z",
     "start_time": "2025-01-20T12:04:29.145905Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def plot_record_curves(record_dict, sample_step=500):\n",
    "    # .set_index(\"step\") 将 step 列设置为 DataFrame 的索引\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    last_step = train_df.index[-1]  # 最后一步的步数\n",
    "\n",
    "    print(train_df)\n",
    "    print(val_df)\n",
    "\n",
    "    # 画图 \n",
    "    fig_num = len(train_df.columns)  # 画两张图,分别是损失和准确率\n",
    "\n",
    "    # plt.subplots：用于创建一个包含多个子图的图形窗口。\n",
    "    # 1：表示子图的行数为 1。\n",
    "    # fig_num：表示子图的列数，即子图的数量。\n",
    "    # figsize=(5 * fig_num, 5)：设置整个图形窗口的大小，宽度为 5 * fig_num，高度为 5。\n",
    "    # fig：返回的图形对象（Figure），用于操作整个图形窗口。\n",
    "    # axs：返回的子图对象（Axes 或 Axes 数组），用于操作每个子图。\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        # train_df.index 是 x 轴数据（通常是 step）。\n",
    "        # train_df[item] 是 y 轴数据（当前指标的值）。\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=\"train:\" + item)\n",
    "        # val_df.index 是 x 轴数据。\n",
    "        # val_df[item] 是 y 轴数据。\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=\"val:\" + item)\n",
    "        axs[idx].grid()  # 显示网格\n",
    "        axs[idx].legend()  # 显示图例\n",
    "        axs[idx].set_xticks(range(0, train_df.index[-1]+1, 5000))  # 设置x轴刻度\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{x // 1000}k\", range(0, last_step + 1, 5000)))  # 设置x轴标签\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_record_curves(record_dict)"
   ],
   "id": "de28437c6058f608",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           loss      acc\n",
      "step                    \n",
      "0      2.302663  0.09375\n",
      "500    2.314181  0.00000\n",
      "1000   2.297616  0.21875\n",
      "1500   2.299287  0.12500\n",
      "2000   2.310017  0.06250\n",
      "...         ...      ...\n",
      "52000  0.238568  0.93750\n",
      "52500  0.409093  0.81250\n",
      "53000  0.175997  0.96875\n",
      "53500  0.432217  0.87500\n",
      "54000  0.131500  0.96875\n",
      "\n",
      "[109 rows x 2 columns]\n",
      "           loss     acc\n",
      "step                   \n",
      "0      2.302611  0.0946\n",
      "1000   2.303340  0.0952\n",
      "2000   2.303822  0.0952\n",
      "3000   2.301817  0.1054\n",
      "4000   2.300612  0.0952\n",
      "5000   2.066800  0.3682\n",
      "6000   0.832378  0.6866\n",
      "7000   0.744561  0.7256\n",
      "8000   0.714989  0.7290\n",
      "9000   0.643285  0.7544\n",
      "10000  0.629686  0.7566\n",
      "11000  0.576579  0.7804\n",
      "12000  0.563359  0.7914\n",
      "13000  0.537878  0.8004\n",
      "14000  0.512915  0.8124\n",
      "15000  0.516214  0.8102\n",
      "16000  0.494902  0.8138\n",
      "17000  0.467019  0.8304\n",
      "18000  0.456843  0.8406\n",
      "19000  0.465133  0.8376\n",
      "20000  0.430231  0.8398\n",
      "21000  0.420529  0.8492\n",
      "22000  0.425884  0.8452\n",
      "23000  0.415880  0.8504\n",
      "24000  0.401563  0.8536\n",
      "25000  0.390907  0.8580\n",
      "26000  0.397299  0.8584\n",
      "27000  0.403611  0.8584\n",
      "28000  0.372380  0.8702\n",
      "29000  0.370183  0.8632\n",
      "30000  0.371135  0.8634\n",
      "31000  0.351188  0.8710\n",
      "32000  0.355359  0.8722\n",
      "33000  0.345268  0.8758\n",
      "34000  0.348021  0.8720\n",
      "35000  0.355452  0.8704\n",
      "36000  0.332178  0.8802\n",
      "37000  0.330720  0.8798\n",
      "38000  0.343412  0.8732\n",
      "39000  0.320400  0.8832\n",
      "40000  0.330769  0.8806\n",
      "41000  0.310660  0.8846\n",
      "42000  0.316730  0.8820\n",
      "43000  0.304229  0.8882\n",
      "44000  0.303627  0.8920\n",
      "45000  0.302772  0.8928\n",
      "46000  0.307715  0.8830\n",
      "47000  0.310233  0.8904\n",
      "48000  0.298552  0.8906\n",
      "49000  0.304345  0.8878\n",
      "50000  0.304961  0.8888\n",
      "51000  0.294100  0.8954\n",
      "52000  0.296022  0.8904\n",
      "53000  0.299972  0.8872\n",
      "54000  0.293854  0.8910\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T12:04:29.421231Z",
     "start_time": "2025-01-20T12:04:29.416439Z"
    }
   },
   "cell_type": "code",
   "source": "record_dict[\"train\"][-5:]",
   "id": "775b113bb78383fa",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.18445485830307007, 'acc': 0.9375, 'step': 53996},\n",
       " {'loss': 0.39255037903785706, 'acc': 0.84375, 'step': 53997},\n",
       " {'loss': 0.21781061589717865, 'acc': 0.9375, 'step': 53998},\n",
       " {'loss': 0.39607465267181396, 'acc': 0.90625, 'step': 53999},\n",
       " {'loss': 0.13149967789649963, 'acc': 0.96875, 'step': 54000}]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T12:04:29.427659Z",
     "start_time": "2025-01-20T12:04:29.421231Z"
    }
   },
   "cell_type": "code",
   "source": "record_dict[\"val\"][-10:]",
   "id": "dbb21c010aaef95e",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.30277191883154736, 'acc': 0.8928, 'step': 45000},\n",
       " {'loss': 0.30771506155372425, 'acc': 0.883, 'step': 46000},\n",
       " {'loss': 0.31023257007454613, 'acc': 0.8904, 'step': 47000},\n",
       " {'loss': 0.29855234045416684, 'acc': 0.8906, 'step': 48000},\n",
       " {'loss': 0.30434480226438515, 'acc': 0.8878, 'step': 49000},\n",
       " {'loss': 0.3049605700786516, 'acc': 0.8888, 'step': 50000},\n",
       " {'loss': 0.29410021334506903, 'acc': 0.8954, 'step': 51000},\n",
       " {'loss': 0.296022348414371, 'acc': 0.8904, 'step': 52000},\n",
       " {'loss': 0.2999718966093033, 'acc': 0.8872, 'step': 53000},\n",
       " {'loss': 0.29385445331027554, 'acc': 0.891, 'step': 54000}]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 评估以及上线",
   "id": "1fa2f200745f7b63"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T12:04:29.436423Z",
     "start_time": "2025-01-20T12:04:29.427659Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = CNN(activation)  #上线时加载模型\n",
    "model = model.to(device)  # 将模型移到GPU上"
   ],
   "id": "b106406c03208c15",
   "outputs": [],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T12:04:37.170177Z",
     "start_time": "2025-01-20T12:04:29.436423Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 加载最好的模型\n",
    "# torch.load：加载保存的模型权重或整个模型。\n",
    "# \"checkpoints/best.ckpt\"：模型权重文件路径。\n",
    "# weights_only=True：仅加载模型的权重，而不是整个模型（包括结构和参数）。这是 PyTorch 2.1 引入的新特性，用于增强安全性。\n",
    "# map_location=device：将模型加载到当前设备（GPU或CPU）。\n",
    "model.load_state_dict(torch.load(\"checkpoints/03_cnn_best.ckpt\", weights_only=True, map_location=device))  # 加载最好的模型\n",
    "\n",
    "model.eval()  # 评估模式\n",
    "loss, acc = evaluate(model, test_loader, loss_fct)\n",
    "print(f\"Test loss: {loss:.4f}, Test acc: {acc:.4f}\")"
   ],
   "id": "26cdacda63d5388e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.3095, Test acc: 0.8884\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T12:04:37.175562Z",
     "start_time": "2025-01-20T12:04:37.171178Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# relu\n",
    "# batch_size = 32 \n",
    "# selu\n",
    "# batch_size = 32 : Test loss: 0.3095, Test acc: 0.8884\n",
    "# batch_size = 64 : Test loss: 0.3256, Test acc: 0.8825"
   ],
   "id": "d4ccef6fa8a0bcff",
   "outputs": [],
   "execution_count": 19
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
